package controleur;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Vector;

import javax.swing.BorderFactory;
import javax.swing.JFileChooser;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.filechooser.FileFilter;

import org.jdom.Element;
import org.jdom.JDOMException;

import outils.Operation;
import outils.PaireClasse;
import outils.PileOperations;
import outils.TypesOperations;
import outils.Divers;

import modele.ModeleClasse;
import modele.ModeleJava;
import modele.ModeleRelation;
import modele.ModeleSauvegarde;
import modele.ModeleToile;
import modele.Relations;

import vue.VueAjoutClasse;
import vue.VueFenetre;
import vue.VuePanelClasse;
import vue.VueToile;


public class ControleurToile implements ActionListener {

	private VueToile vt;
	private VueFenetre vf;
	private VueAjoutClasse vac;
	private boolean dessinerClasse = false;
	private String dernierFichier = "";
	private JFileChooser fc;
	private int xCopier = 5;
	private int yCopier = 5;
	
	public static String nomToile = "Nouveau Diagramme";
	public static String nomProg = "KCK UML";
	public static int dessinerRelation = 0;
	public static Relations rel = null;
	public static PileOperations pileUndo = new PileOperations();
	public static PileOperations pileRedo = new PileOperations();
	public static VuePanelClasse classeAcopier = null;
	
	private String [] tabFics;
	private int nbFics;
	
	public ControleurToile(VueToile t, VueFenetre f) {
		this.vt = t;
		this.vf = f;
		this.vt.addMouseListener(new MouseToile());
		this.fc = new JFileChooser();
		this.fc.setMultiSelectionEnabled(false);
		this.fc.setFileSelectionMode(JFileChooser.FILES_ONLY);
		this.fc.setFileFilter(new FiltreFichier(Divers.EXTENSION));
		this.tabFics = new String[10];
		this.nbFics = 0;
		
		vf.setTitle(nomToile + " - KCK UML");
	}
	
	public void setF(VueAjoutClasse f) {
		this.vac = f;
	}
	
	public class MouseToile implements MouseListener {
		
		public void mouseClicked(MouseEvent e) {
			if(e.getButton() == MouseEvent.BUTTON3) {
				if(classeAcopier != null) {
					JPopupMenu jpm = new JPopupMenu();
					
					JMenuItem coller = new JMenuItem("Coller");
					coller.setActionCommand("CollerClasse");
					coller.addActionListener(ControleurToile.this);
					jpm.add(coller);
					
					xCopier = e.getX();
					yCopier = e.getY();
					
					jpm.setVisible(true);
					jpm.show(vt, e.getX(), e.getY());
				}
			}
			else if(dessinerClasse) {
				vac = new VueAjoutClasse(ControleurToile.this, e.getX(), e.getY(), vt);
				vt.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
				dessinerClasse = false;
			}
			else if(dessinerRelation == 1 || dessinerRelation == 2) {
				dessinerRelation = 0;
				rel = null;
				vt.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
			}
			else {
				if(ControleurPanelClasse.classeSelectionnee != null) {
					ControleurPanelClasse.classeSelectionnee.setBorder(BorderFactory.createLineBorder(Color.BLACK));
					ControleurPanelClasse.classeSelectionnee = null;
					vf.setCopyAndCutBtnEnabled(false);
				}
			}
			
		}

		public void mouseEntered(MouseEvent e) {}

		public void mouseExited(MouseEvent e) {}

		public void mousePressed(MouseEvent e) {}

		public void mouseReleased(MouseEvent e) {}
	}
	
	public void actionPerformed(ActionEvent e) {
		String etiquette = e.getActionCommand();
		
		if(etiquette.equals("Quitter")) {
			
			if(!pileUndo.estVide() && !pileUndo.getElementEnTete().isEstSauvegardee()) {
				int option = JOptionPane.showConfirmDialog(this.vf,
						"Voulez-vous enregistrer vos modifications avant de quitter ?",
						"Attention",
						JOptionPane.YES_NO_CANCEL_OPTION);

				if(option == JOptionPane.YES_OPTION || option == JOptionPane.NO_OPTION) {	
					if(option == JOptionPane.YES_OPTION) {
						System.out.println("YES");
						try {
							ModeleSauvegarde ms = new ModeleSauvegarde(vt.getModele().getListeClasse(), 
									vt.getModele().getListeRelation());
							ms.sauvegarder(this.dernierFichier);
						} catch (IOException e1) {
							e1.printStackTrace();
						}
						vf.setSauvegarderBtnEnabled(false);
						pileUndo.getElementEnTete().setEstSauvegardee(true);
					}
					
					System.exit(1);
				}
			}
			else {
				System.exit(1);
			}
		}
		
		else if(etiquette.equals("NewClasse")) {
			dessinerClasse = true;
			Toolkit tk = Toolkit.getDefaultToolkit();
			Image img = tk.getImage("Images/addClasse.gif");
			Cursor monCurseur = tk.createCustomCursor(img, new Point(0, 0), "ajout");
			vt.setCursor(monCurseur);
		}

		else if(etiquette.equals("ValiderAjout")) {
			/* On vérifie si le nom de la classe existe déjà */
			if(Divers.nomDeClasseExisteDeja(vt, vac.getTxtnc().getText())) {
				JOptionPane.showMessageDialog(vf, "Ce nom de classe est déjà utilisé !");
			}
			else {
				vac.setVisible(false);
				
				/* On ajoute un modéle correspondant à la classe dans le modéle de la toile */
				ModeleClasse m = Divers.getModeleClasseOfVac(this.vac);
			    vt.ajouterClasse(m);
			    
				/* On ajoute un panel de la classe sur la toile */
				int x = vac.getX();
				int y = vac.getY();
				VuePanelClasse vpc = new VuePanelClasse(m);
				vpc.setLocation(x,y);
				vpc.setControleur(new ControleurPanelClasse(vpc, vf, vt));
				vt.add(vpc, null);
				
				// Permet d'afficher le panel à une position absolue
				Insets insets = vt.getInsets();
		        Dimension size = vpc.getPreferredSize();
		        vpc.setBounds(x + insets.left, y + insets.top, size.width, size.height);
				
		        /* On ajoute l'ajout de la classe à la pile des opérations */
		        pileUndo.empiler(new Operation(vpc, TypesOperations.AJOUT_CLASSE, false));
		        nouvelleOperation();
		        vf.setGenerateBtnEnabled(true);
		        
				/* Enfin, on redessine la fenêtre */
				vf.pack();
				vf.repaint();
			}
		}
		
		else if(etiquette.equals("CopierClasse")) {
			classeAcopier = ControleurPanelClasse.classeSelectionnee;
			vf.setPasteBtnEnabled(true);
		}
		
		else if(etiquette.equals("CouperClasse")) {
			classeAcopier = ControleurPanelClasse.classeSelectionnee;
			ControleurPanelClasse.classeSelectionnee.getControleur().supprimerClasse();
			vf.setCopyAndCutBtnEnabled(false);
			vf.setPasteBtnEnabled(true);
		}
		
		else if(etiquette.equals("CollerClasse")) {
			/* On ajoute un modéle correspondant à la classe dans le modéle de la toile */
			ModeleClasse m = new ModeleClasse(classeAcopier.getModele());
		    vt.ajouterClasse(m);
		    
			/* On ajoute un panel de la classe sur la toile */
			VuePanelClasse vpcColler = new VuePanelClasse(m);
			vpcColler.setLocation(xCopier, yCopier);
			vpcColler.getModele().setPosition(xCopier, yCopier);
			vpcColler.setControleur(new ControleurPanelClasse(vpcColler, vf, vt));
			vt.add(vpcColler, null);
			
			// Permet d'afficher le panel à une position absolue
			Insets insets = vt.getInsets();
	        Dimension size = vpcColler.getPreferredSize();
	        vpcColler.setBounds(xCopier + insets.left, yCopier + insets.top, size.width, size.height);
			
	        /* On ajoute l'ajout de la classe à la pile des opérations */
	        pileUndo.empiler(new Operation(vpcColler, TypesOperations.AJOUT_CLASSE, false));
	        nouvelleOperation();
	        
			/* Enfin, on redessine la fenêtre */
			vf.pack();
			vf.repaint();

			xCopier += 5;
			yCopier += 5;
		}
		
		else if(etiquette.equalsIgnoreCase("NewAssociation")) {
			if(dessinerClasse) dessinerClasse = false;
			Toolkit tk = Toolkit.getDefaultToolkit();
			Image img = tk.getImage("Images/addAssociation.gif");
			Cursor monCurseur = tk.createCustomCursor(img, new Point(0, 0), "ajout");
			vt.setCursor(monCurseur);
			dessinerRelation = 1;
			rel = Relations.ASSOCIATION;
		}
		
		else if(etiquette.equalsIgnoreCase("NewComposition")) {
			if(dessinerClasse) dessinerClasse = false;
			Toolkit tk = Toolkit.getDefaultToolkit();
			Image img = tk.getImage("Images/addComposition.gif");
			Cursor monCurseur = tk.createCustomCursor(img, new Point(0, 0), "ajout");
			vt.setCursor(monCurseur);
			dessinerRelation = 1;
			rel = Relations.COMPOSITION;
		}
		
		else if(etiquette.equalsIgnoreCase("NewAgregation")) {
			if(dessinerClasse) dessinerClasse = false;
			Toolkit tk = Toolkit.getDefaultToolkit();
			Image img = tk.getImage("Images/addAgregation.gif");
			Cursor monCurseur = tk.createCustomCursor(img, new Point(0, 0), "ajout");
			vt.setCursor(monCurseur);
			dessinerRelation = 1;
			rel = Relations.AGREGATION;
		}
		
		else if(etiquette.equalsIgnoreCase("OuvrirDerniers")) {
			System.out.println("ouvrir un des dernier fichier ouverts");
			JMenuItem jmi = (JMenuItem) e.getSource();
			this.dernierFichier = jmi.getText();
			
			ouvrirFichier();
		}
		
		else if(etiquette.equalsIgnoreCase("NouveauFichier")) {
			boolean annuler = false;
			
			//si le projet n'a pas été sauvegardé et qu'il y a eu des modifications
			//on propose la sauvegarde
			if(!pileUndo.estVide() && !pileUndo.getElementEnTete().isEstSauvegardee())  {
				int option = JOptionPane.showConfirmDialog(this.vf,
						"Voulez-vous enregistrer vos modifications avant d'ouvrir un autre projet?",
						"Attention",
						JOptionPane.YES_NO_CANCEL_OPTION);

				if(option == JOptionPane.YES_OPTION || option == JOptionPane.NO_OPTION) {
					if(option == JOptionPane.YES_OPTION) {
						try {
							ModeleSauvegarde ms = new ModeleSauvegarde(vt.getModele().getListeClasse(),
									vt.getModele().getListeRelation());
							ms.sauvegarder(this.dernierFichier);
						} catch (IOException e1) {
							e1.printStackTrace();
						}
						vf.setSauvegarderBtnEnabled(false);
						pileUndo.getElementEnTete().setEstSauvegardee(true);
					}
				}
				else {
					annuler = true;
				}
			}
			
			if(!annuler) {
				// On supprime tout le contenu de la vue et du modéle
				vt.getModele().supprimerToutesLesClasses();
				vt.getModele().supprimerToutesLesRelations();
				
				vt.supprimerToutesLesRelations();
				vt.removeAll();
				
				pileUndo.vider();
				pileRedo.vider();
				
				classeAcopier = null;
				ControleurPanelClasse.classeSelectionnee = null;
				this.dernierFichier = "";
				
				vf.setUndoBtnEnabled(false);
				vf.setRedoBtnEnabled(false);
				vf.setCopyAndCutBtnEnabled(false);
				vf.setPasteBtnEnabled(false);
				vf.setGenerateBtnEnabled(false);
				vf.setSauvegarderBtnEnabled(false);
				
				nomToile = "Nouveau Diagramme";
				vf.setTitle(nomToile + " - KCK UML");
				
				vf.pack();
				vf.repaint();
			}
		}
		
		else if(etiquette.equalsIgnoreCase("Ouvrir")) {
			boolean annuler = false;
			boolean pasDerreur = true;

			//si le projet n'a pas été sauvegardé et qu'il y a eu des modifications
			//on propose la sauvegarde
			if(!pileUndo.estVide() && !pileUndo.getElementEnTete().isEstSauvegardee())  {
				int option = JOptionPane.showConfirmDialog(this.vf,
						"Voulez-vous enregistrer vos modifications avant d'ouvrir un autre projet?",
						"Attention",
						JOptionPane.YES_NO_CANCEL_OPTION);

				if(option == JOptionPane.YES_OPTION || option == JOptionPane.NO_OPTION) {
					if(option == JOptionPane.YES_OPTION) {
						try {
							ModeleSauvegarde ms = new ModeleSauvegarde(vt.getModele().getListeClasse(),
									vt.getModele().getListeRelation());
							ms.sauvegarder(this.dernierFichier);
						} catch (IOException e1) {
							e1.printStackTrace();
						}
						vf.setSauvegarderBtnEnabled(false);
						pileUndo.getElementEnTete().setEstSauvegardee(true);
					}
					
					pasDerreur = this.choisiFichierOuvrir();
				}
				else {
					annuler = true;
				}
			}
			else {
				pasDerreur = this.choisiFichierOuvrir();
			}
			
			if(!annuler && pasDerreur) {
				// a ce stade on a forcément le this.dernierFichier qui est rempli
				if(nbFics == 10) {
					for(int i = 0 ; i < (this.tabFics.length-1) ; i++) {
						this.tabFics[i] = this.tabFics[i+1];
					}
					this.tabFics[nbFics-1] = this.dernierFichier;
				}
				else {
					this.tabFics[nbFics] = this.dernierFichier;
					nbFics++;
				}
				
				//on met à jour les dix derniers fichiers
				vf.setLastFile(this.tabFics);
				
				ouvrirFichier();
			}
		}
		
		else if(etiquette.equalsIgnoreCase("Enregistrer")) {
			//s'il n'y a pas eu de fichier de selectionner
			if(this.dernierFichier.equalsIgnoreCase("")) {
				if(this.choisiFichierSauvegarde()) {
					sauvegarder();
				}
			}
			else {
				sauvegarder();
			}
		}
		
		else if(etiquette.equalsIgnoreCase("Enregistrer sous ...")) {
			if(this.choisiFichierSauvegarde()) {
				sauvegarder();
			}
		}
		
		else if(etiquette.equalsIgnoreCase("AnnulerOperation")) {
			Operation op = null;
			
			do {
				op = pileUndo.depiler();
				VuePanelClasse vpc = op.getClasse();
				
				String msg = "";
				
				switch(op.getType()) {
					case AJOUT_CLASSE :
						if(ControleurPanelClasse.classeSelectionnee != null && ControleurPanelClasse.classeSelectionnee == vpc) {
							ControleurPanelClasse.classeSelectionnee = null;
							vf.setCopyAndCutBtnEnabled(false);
						}
						vt.getModele().supprimer(vpc.getModele());
						vt.remove(vpc);
						msg = "AJOUT_CLASSE";
					break;
					
					case MODIF_CLASSE :
						vpc.setModele(op.getAncienModele());
						msg = "MODIF_CLASSE";
					break;
					
					case SUPP_CLASSE :
						vt.ajouterClasse(vpc.getModele());
						vpc.setBorder(BorderFactory.createLineBorder(Color.black));
						vt.add(vpc, null);
						
						Insets insets = vt.getInsets();
				        Dimension size = vpc.getPreferredSize();
				        vpc.setBounds(vpc.getX() + insets.left, vpc.getY() + insets.top, size.width, size.height);
				        msg = "SUPP_CLASSE";
					break;
					
					case DEPLACEMENT :
						int x = vpc.getX();
						int y = vpc.getY();
						
						vpc.setLocation(op.getX(), op.getY());
						vpc.getModele().setPosition(op.getX(), op.getY());
						
						op.setX(x);
						op.setY(y);
						msg = "DEPLACEMENT";
					break;
					
					case AJOUT_REL :
						vt.enleverRelation(op.getRelation());
						msg = "AJOUT_REL";
					break;
					
					case MODIF_REL :
						PaireClasse aRemettre = op.getRelation();
						// on supprime la relation actuelle
						Vector<PaireClasse> listeAssoc = vt.getListeRelations();
						PaireClasse aSupprimer = new PaireClasse();
						for(PaireClasse pc : listeAssoc) {
							if(pc.getVpc1() == aRemettre.getVpc1() && pc.getVpc2() == aRemettre.getVpc2()
									&& pc.getTypeRelations() == Relations.ASSOCIATION) {
								aSupprimer = pc;
							}
						}
						op.setRelation(new PaireClasse(aSupprimer));
						vt.enleverRelation(aSupprimer);
						
						// et on rajoute l'ancienne
						vt.nouvelleRelation(aRemettre);
						
						msg = "MODIF_REL";
					break;
					
					case SUPP_REL :
						vt.nouvelleRelation(op.getRelation());
						msg = "SUPP_REL";
					break;
					
					default :
					break;
				}
				
				System.out.println("UNDO de : " + msg);
				
				pileRedo.empiler(op);
				
				if(vt.getComponentCount() == 0) {
					vf.setGenerateBtnEnabled(false);
				}
				
				if(pileUndo.estVide()) {
					vf.setUndoBtnEnabled(false);
					vf.setSauvegarderBtnEnabled(false);
					vf.setTitle(nomToile + " - " + nomProg);
				}
				else if(pileUndo.getElementEnTete().isEstSauvegardee()) {
					vf.setSauvegarderBtnEnabled(false);
					vf.setTitle(nomToile + " - " + nomProg);
				}
				else {
					vf.setSauvegarderBtnEnabled(true);
					vf.setTitle("*" + nomToile + " - " + nomProg);
				}
			}
			while(op.isContinuerUndo());

			vf.setRedoBtnEnabled(true);
			vf.pack();
			vf.repaint();
		}
		
		else if(etiquette.equalsIgnoreCase("RefaireOperation")) {
			Operation op = null;
			
			do {
				op = pileRedo.depiler();
				VuePanelClasse vpc = op.getClasse();
				
				String msg = "";
				
				switch(op.getType()) {
					case AJOUT_CLASSE :
						vt.ajouterClasse(vpc.getModele());
						vpc.setBorder(BorderFactory.createLineBorder(Color.black));
						vt.add(vpc, null);
						
						Insets insets = vt.getInsets();
				        Dimension size = vpc.getPreferredSize();
				        vpc.setBounds(vpc.getX() + insets.left, vpc.getY() + insets.top, size.width, size.height);
				        msg = "AJOUT_CLASSE";
					break;
					
					case MODIF_CLASSE :
						vpc.setModele(op.getNouveauModele());
						msg = "MODIF_CLASSE";
					break;
					
					case SUPP_CLASSE :
						if(ControleurPanelClasse.classeSelectionnee != null && ControleurPanelClasse.classeSelectionnee == vpc) {
							ControleurPanelClasse.classeSelectionnee = null;
							vf.setCopyAndCutBtnEnabled(false);
						}
						vt.getModele().supprimer(vpc.getModele());
						vt.remove(vpc);
						msg = "SUPP_CLASSE";
					break;
					
					case DEPLACEMENT :
						int x = vpc.getX();
						int y = vpc.getY();
						
						vpc.setLocation(op.getX(), op.getY());
						vpc.getModele().setPosition(op.getX(), op.getY());
						
						op.setX(x);
						op.setY(y);
						msg = "DEPLACEMENT";
					break;
					
					case AJOUT_REL :
						vt.nouvelleRelation(op.getRelation());
						msg = "AJOUT_REL";
					break;
					
					case MODIF_REL :
						PaireClasse aRemettre = op.getRelation();
						
						// on supprime la relation actuelle
						Vector<PaireClasse> listeAssoc = vt.getListeRelations();
						PaireClasse aSupprimer = new PaireClasse();
						for(PaireClasse pc : listeAssoc) {
							if(pc.getVpc1() == aRemettre.getVpc1() && pc.getVpc2() == aRemettre.getVpc2()
									&& pc.getTypeRelations() == Relations.ASSOCIATION) {
								aSupprimer = pc;
							}
						}
						op.setRelation(new PaireClasse(aSupprimer));
						vt.enleverRelation(aSupprimer);
						
						// et on rajoute l'ancienne
						vt.nouvelleRelation(aRemettre);
						
						msg = "MODIF_REL";
					break;
					
					case SUPP_REL :
						vt.enleverRelation(op.getRelation());
						msg = "SUPP_REL";
					break;
					
					default :
					break;
				}
				
				System.out.println("REDO de : " + msg);
				
				if(pileUndo.estVide())
					vf.setGenerateBtnEnabled(true);
					
				pileUndo.empiler(op);
				
				if(pileRedo.estVide()) {
					vf.setRedoBtnEnabled(false);
				}
				
				if(pileUndo.getElementEnTete().isEstSauvegardee()) {
					vf.setSauvegarderBtnEnabled(false);
					vf.setTitle(nomToile + " - " + nomProg);
				}
				else {
					vf.setSauvegarderBtnEnabled(true);
					vf.setTitle("*" + nomToile + " - " + nomProg);
				}
			}
			while(op.isContinuerRedo());
			
			vf.setUndoBtnEnabled(true);
			vf.pack();
			vf.repaint();
		}
		
		else if (etiquette.equalsIgnoreCase("GenererCode")) {
			try {
				
				new ModeleJava("/home/kn/workspace/IG_Projet/src/Java",
						"/home/kn/workspace/IG_Projet/src/TypesJava.xml", this.vt.getModele()
						.getListeClasse(),this.vt.getModele()
						.getListeRelation()).genereCode(ModeleToile.urlGeneration);
			} catch (IOException e1) {
				e1.printStackTrace();
			} catch (JDOMException e4) {
				e4.printStackTrace();
			}
		}
		
		else if(etiquette.equalsIgnoreCase("DossierDest")) {
			int res = this.fc.showDialog(this.vf, "ok");
			if(res == JFileChooser.APPROVE_OPTION) {
				if(this.fc.getSelectedFile().isDirectory())
				{
					ModeleToile.urlGeneration = fc.getSelectedFile().getPath();
				}
			}
		}
	}
	
	public class FiltreFichier extends FileFilter {
		
		private String extensionFichier;
		
		public FiltreFichier(String extension) {
			this.extensionFichier = extension;
		}
		
		public boolean accept(File f) {
			if(f.isDirectory()) { 
				return true; 
			} 
			String nomFichier = f.getName().toLowerCase();
		    return nomFichier.endsWith(this.extensionFichier);
		}

		public String getDescription() {
			return "Fichiers :" + this.extensionFichier;
		}
		
	}
	
	public boolean choisiFichierSauvegarde()	{
		int res = fc.showSaveDialog(this.vf);
		
		if(res == JFileChooser.APPROVE_OPTION) {
			File f = fc.getSelectedFile();
			String temp[] = f.getName().split(".");
			this.dernierFichier = f.getPath();
			//si le fichier n'a pas d'extension on rajoute le .kck
			if(temp.length <= 1)
				this.dernierFichier += Divers.EXTENSION;
			return true;
		}
		
		return false;
	}
	
	public boolean choisiFichierOuvrir() {
		int res = fc.showOpenDialog(this.vf);
		
		if(res == JFileChooser.APPROVE_OPTION) {
			File f = fc.getSelectedFile();
			this.dernierFichier = f.getPath();
			System.out.println("le fichier selectionne est " + f.getPath());
			return true;
		}
		
		return false;
	}
	
	public void sauvegarder() {
		try {
			ModeleSauvegarde ms = new ModeleSauvegarde(
					vt.getModele().getListeClasse(),
					vt.getModele().getListeRelation());
			ms.sauvegarder(this.dernierFichier);
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		String[] tmp = this.dernierFichier.split("/");
		nomToile = tmp[tmp.length-1];
		vf.setTitle(nomToile + " - " + nomProg);
		vf.setSauvegarderBtnEnabled(false);
		
		if(!pileUndo.estVide()) {
			pileUndo.getElementEnTete().setEstSauvegardee(true);
			
			PileOperations temp = new PileOperations();
			temp.empiler(pileUndo.depiler());
			boolean trouve = false;
			
			while(!pileUndo.estVide() && !trouve) {
				if(pileUndo.getElementEnTete().isEstSauvegardee()) {
					pileUndo.getElementEnTete().setEstSauvegardee(false);
					trouve = true;
				}
				else {
					temp.empiler(pileUndo.depiler());
				}
			}
			
			while(!temp.estVide()) {
				pileUndo.empiler(temp.depiler());
			}
		}
	}
	
	public void ouvrirFichier() {
		String[] tmp = this.dernierFichier.split("/");
		nomToile = tmp[tmp.length-1];
		vf.setTitle(nomToile + " - " + nomProg);
		
		try {
			List<Element> tmpClasse = Divers.listFromXml(this.dernierFichier, Divers.CLASSES);
			List<Element> tmpRelation = Divers.listFromXml(this.dernierFichier, Divers.RELATIONS);
			
			Vector<ModeleClasse> classes = (Vector<ModeleClasse>) Divers.chargement(tmpClasse,Divers.CLASSES);
			Vector<ModeleRelation> relations = (Vector<ModeleRelation>) Divers.chargement(tmpRelation,Divers.RELATIONS);
			// On enléve toutes les classes de la vue
			this.vt.removeAll();
			// On lui affecte le modèle du fichier à charger
			this.vt.setModele(new ModeleToile(classes, relations));
			
			// On redessine toutes les classes
			this.vt.dessinerChargement(vf);
			// On redessine les relations
			this.vt.chargerRelations(relations);
			
			this.vf.setRedoBtnEnabled(false);
			this.vf.setUndoBtnEnabled(false);
			this.vf.setSauvegarderBtnEnabled(false);
			this.vf.setGenerateBtnEnabled(true);
			ControleurToile.pileRedo.vider();
			ControleurToile.pileUndo.vider();
			
			this.vf.pack();
			this.vf.repaint();
			
		} catch (JDOMException e1) {
			e1.printStackTrace();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}
	
	public void nouvelleOperation() {
		pileRedo.vider();
		vf.setUndoBtnEnabled(true);
        vf.setRedoBtnEnabled(false);
        vf.setSauvegarderBtnEnabled(true);
        vf.setTitle("*" + nomToile + " - " + nomProg);
	}
}
